home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / gnu / hp2xx312.lha / hp2xx312 / old / to_atari.c < prev    next >
C/C++ Source or Header  |  1993-04-18  |  32KB  |  1,019 lines
  1. /*
  2.    Copyright (C) 1992 Norbert Meyer.  All rights reserved.
  3.    Distributed by Free Software Foundation, Inc.
  4.  
  5. This file is part of HP2xx.
  6.  
  7. HP2xx is distributed in the hope that it will be useful, but
  8. WITHOUT ANY WARRANTY.  No author or distributor accepts responsibility
  9. to anyone for the consequences of using it or for whether it serves any
  10. particular purpose or works at all, unless he says so in writing.  Refer
  11. to the GNU General Public License, Version 2 or later, for full details.
  12.  
  13. Everyone is granted permission to copy, modify and redistribute
  14. HP2xx, but only under the conditions described in the GNU General Public
  15. License.  A copy of this license is supposed to have been
  16. given to you along with HP2xx so you can know your rights and
  17. responsibilities.  It should be in a file named COPYING.  Among other
  18. things, the copyright notice and this notice must be preserved on all
  19. copies.
  20.  
  21. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  22. */
  23.  
  24. /**
  25.  ** TO_ATARI.C:  Zweite Version für einen Atari-Previewer im
  26.  **              Rahmen des HP2xx-Projektes von Heinz Werntges.
  27.  **
  28.  **              Die erste Version für einen Atari-Previewer
  29.  **              wertete jeweils die temporäre Datei aus, in der
  30.  **              zunächst in einem HP2xx-spezifischem Code alle
  31.  **              Plot-Anweisungen gesammelt werden (Diese
  32.  **              Zwischendatei wird von HP2xx benutzt, um
  33.  **              anschlie₧end daraus zum einen die HP2xx-Bitmap zu
  34.  **              erzeugen, und zum anderen um auf dieser Grundlage
  35.  **              vektororientierte Datei-Formate wie das
  36.  **              Postscript-Format zu errechnen).
  37.  **
  38.  **              Dieses Vorgehen hatte aber einen entscheidenden
  39.  **              Nachteil: Da der Vektorteil von HP2xx von Zeit zu
  40.  **              Zeit weiterentwickelt wird, mu₧te dann jeweils
  41.  **              auch der Atari-Previewer angepa₧t werden.
  42.  **
  43.  **              Daher wertet die neue Version nun nicht mehr den
  44.  **              Vektorteil des HP2xx aus. Stattdessen wird die
  45.  **              von HP2xx zur Verfügung gestellte Bitmap als
  46.  **              Berechnungsgrundlage genommen. Für die Bitmap ist
  47.  **              ein festes Format garantiert, so da₧ der
  48.  **              Previewer auf lange Sicht nicht mehr geändert
  49.  **              werden mu₧.
  50.  **
  51.  **              Der Atari-Previewer nutzt nur VDI-Zeichenbefehle.
  52.  **              Dadurch ist er zwar nicht gerade einer der
  53.  **              schnellsten, sollte aber in jeder auf dem Atari
  54.  **              verfügbaren Graphikauflösung arbeiten.
  55.  **
  56.  **              Zudem bietet der Previewer bescheidenen
  57.  **              Bedienungskomfort (Scrollen durch ein zu gro₧
  58.  **              geratenes Bild per Pfeiltasten, Hilfstext
  59.  **              abrufbar). Auf eine komplette Fensterverwaltung
  60.  **              wurde jedoch verzichtet. Dies hätte den Previewer
  61.  **              zum einen unnötig aufgebläht und zum anderen wäre
  62.  **              es schon irgendwie merkwürdig gewesen, wenn nach
  63.  **              einem rein buchstabenorientiertem Programmteil
  64.  **              auf einmal ein typisches GEM-Programm auf dem
  65.  **              Schirm erscheint.
  66.  **
  67.  **              Damit der Benutzer sich nicht so sehr mit den
  68.  **              Besonderheiten seines Bildschirms herumplagen
  69.  **              mu₧, beachtet der Atari-Previewer Bildschirm-
  70.  **              auflösungen mit sehr ungleich gro₧en Pixeln (ein
  71.  **              typischer Fall ist die mittlere Auflösung für den
  72.  **              Atari ST). Ist also in der Bitmap für die x- und
  73.  **              die y-Richtung jeweils die gleiche Auflösung
  74.  **              gewählt, so erscheint im Preview ein Kreis
  75.  **              (wenigstens so ungefähr) auch auf dem Bildschirm
  76.  **              als Kreis - unabhängig davon, ob man etwas
  77.  **              merkwürdige Graphikeigenschaften in seinem
  78.  **              Rechner hat oder nicht.
  79.  **
  80.  **              Bisher wurde der Previewer mit folgenden
  81.  **              Bildschirmauflösungen getestet (sollte aber - wie
  82.  **              gesagt - auch bei anderen Bildschirmauflösungen
  83.  **              laufen):
  84.  **
  85.  **              - ST niedrig ( 320 x 200, 16 Farben)
  86.  **
  87.  **              - ST mittel  ( 640 x 200, 4 Farben)
  88.  **
  89.  **              - ST hoch    ( 640 x 400, monochrom)
  90.  **
  91.  **              Trotz ausführlicher Test mu₧ aber darauf
  92.  **              hingewiesen werden, da₧ die Benutzung des
  93.  **              Atari-Previewer auf eigene Gefahr geschieht.
  94.  **/
  95.  
  96. /**  V. 0.00  16.05.92 NM Null-Version (nicht lauffähig)
  97.  **  V. 1.00  22.05.92 NM erste lauffähige Version
  98.  **/
  99.  
  100. /**
  101.  **  Standard-Header für GEM-Programme:
  102.  **/
  103.  
  104. #include <tos.h>
  105. #include <vdi.h>
  106. #include <aes.h>
  107. #include <stdio.h>
  108. #include <stdlib.h>
  109.  
  110. /**
  111.  **  Header für HP2xx:
  112.  **/
  113.  
  114. #include "bresnham.h"
  115. #include "hp2xx.h"
  116.  
  117. /**
  118.  **  ergänzende Standard-Definitionen für GEM-Programme:
  119.  **/
  120.  
  121. typedef enum {          /* boolean definieren   */
  122.     FALSCH,
  123.     WAHR
  124. } boolean;
  125.  
  126. #define CON     2       /* Console (VT-52)  */
  127.  
  128.  
  129. /*
  130.  *  weitere Definitionen:
  131.  */
  132.  
  133. #define CLS     printf("%cE",27);   /* Bildschirm löschen   */
  134.  
  135.                                     /* Scancodes:           */
  136. #define SC_H        35              /* H    \               */
  137. #define SC_HELP     98              /* Help  >  gl. Fkt.    */
  138. #define SC_F1       59              /* F1   /               */
  139. #define SC_I        23              /* I für Info           */
  140. #define SC_Q        16              /* Q    \ Programm-     */
  141. #define SC_ESC      1               /* Esc  / abbruch       */
  142. #define SC_PF_LKS   75              /* Pfeil links          */
  143. #define SC_C_PF_LKS 115             /* Control Pfeil links  */
  144. #define SC_PF_RTS   77              /* Pfeil rechts         */
  145. #define SC_C_PF_RTS 116             /* Control Pfeil rechts */
  146. #define SC_PF_OBN   72              /* Pfeil nach oben      */
  147. #define SC_PF_UTN   80              /* Pfeil nach unten     */
  148.  
  149.                                     /* Sondertastenbits:    */
  150. #define KB_SHIFT_RTS        1       /* Shift-rechts         */
  151. #define KB_SHIFT_LKS        2       /* Shift-links          */
  152. #define KB_CONTROL          4       /* Control              */
  153. #define KB_ALTERNATE        8       /* Alternate            */
  154.  
  155.  
  156. /*
  157.  *  globale Variablen für GEM-Programme:
  158.  */
  159.  
  160. int gl_apid;        /* Applikations-Identifikationsnummer   */
  161.  
  162. int phys_handle,    /* physikalisches Handle (GRAF_HANDLE)  */
  163.     vdi_handle;     /* VDI-Handle (V_OPENVWK)               */
  164.  
  165. int gl_hchar,       /* Höhe,                                */
  166.     gl_wchar,       /* Breite eines Standard-Zeichens       */
  167.     gl_hbox,        /* Höhe, Breite der Box um ein          */
  168.     gl_wbox;        /* Zeichen des Standard-Zeichensatzes   */
  169.  
  170. int w_text,         /* Anzahl Standard-Zeichen pro Zeile    */
  171.     h_text;         /* Anzahl Zeilen                        */
  172.  
  173. int work_in[12],    /* Parameterübergabe-Felder für         */
  174.     work_out[57],   /* VDI-Aufrufe (inkl. V_OPENVWK)        */
  175.     pxyarray[10];
  176.  
  177. int cntrl[12],      /* vom VDI und AES benutzte Parameter-  */
  178.     initin[128],    /* übergabefelder                       */
  179.     ptsin[128],
  180.     intout[128],
  181.     ptsout[128];
  182.  
  183. int w_screen,       /* Größe des Schirms insgesamt          */
  184.     h_screen,
  185.     w_pixel,        /* Pixelbreite /-höhe in 1/1000 mm      */
  186.     h_pixel,
  187.     color_max,      /* gleichzeitig verfügbare Farben       */
  188.     color_palette;  /* Anzahl Farben insgesamt              */
  189.  
  190. /**
  191.  **  Globale Variablen für den ATARI-Previewer
  192.  **/
  193.  
  194. int rx,             /* Reale Schirmpositionen, Grö₧e des    */
  195.     rx_min,         /* Schirms und Korrekturfaktoren für    */
  196.     rx_max,         /* nicht quadratische Pixel             */
  197.     rx_factor,
  198.     ry,
  199.     ry_min,
  200.     ry_max,
  201.     ry_factor;
  202.  
  203. static Byte rx_reihe[3000]; /* eine Pixelreihe auf dem      */
  204.                             /* Schirm (sollte auch für Gro₧-*/
  205.                             /* bildschirme reichen)         */
  206.  
  207. int sx_min,         /* Schirmausmaße nach Korrektur für     */
  208.     sx_max,         /* nicht quadratische Pixel             */
  209.     sy_min,
  210.     sy_max;
  211.  
  212. int dx,             /* Darzustellender Bildausschnitt nach  */
  213.     dx_min,         /* Korrektur für nicht quadratische     */
  214.     dx_max,         /* Pixel                                */
  215.     dy,
  216.     dy_min,
  217.     dy_max;
  218.  
  219. int px,             /* Position innerhalb und Grö₧e der     */
  220.     px_min,         /* Bitmap (in Pixeleinheiten)           */
  221.     px_max,
  222.     py,
  223.     py_min,
  224.     py_max;
  225.  
  226. int ox,             /* Offset zur Umrechnung vom p- ins d-  */
  227.     oy;             /* System                               */
  228.  
  229. /**
  230.  **  Funktionsprototypen für GEM-Initialisation:
  231.  **/
  232.  
  233. boolean open_vwork  (void);             /* Öffnet virtuele Workstation  */
  234. void    close_vwork (void);             /* Schließt virt. Workstation   */
  235.  
  236. /**
  237.  **  HP2xx - Funktionsprototypen:
  238.  **/
  239.  
  240. void    PicBuf_to_ATARI (PicBuf *, PAR *);  /* GEM-Initialisierung und  */
  241.                                             /* Termination (Hauptprg.)  */
  242.  
  243.     void    preview (PicBuf *);             /* Vorbelegungen, Tasten-   */
  244.                                             /* drücke auswerten         */
  245.  
  246.         void    hilfe (void);               /* Gibt Hilfstext aus       */
  247.  
  248.         void    info  (void);               /* Bildschirmparameter-Info */
  249.  
  250.         void    zeichne (PicBuf *);         /* Führt Graphik aus        */
  251.  
  252.             int  lese_pixel(PicBuf *);          /* Liest einzeln. Pixel */
  253.             void zeichne_pixelreihe (void);     /* Zeichnet Pixelreihe  */
  254.  
  255.  
  256. /*------------------------------------------------------------------*/
  257.  
  258.  
  259. /**
  260.  ** open_vwork:  Öffnet die Workstation, fragt wichtigste Kenndaten
  261.  **              ab
  262.  **/
  263.  
  264. boolean open_vwork(void)
  265. {
  266.     int i;
  267.  
  268.     if ((gl_apid = appl_init()) != -1) {
  269.  
  270.         /* phys. Handle und Standard-Zeichengrö₧e erfragen  */
  271.  
  272.         phys_handle = graf_handle(&gl_wchar, &gl_hchar, &gl_wbox,
  273.                                   &gl_hbox);
  274.         vdi_handle = phys_handle;
  275.  
  276.         /* work_in vorbesetzen, virtuelle Workstation auf   */
  277.         /* Bildschirm öffnen                                */
  278.  
  279.         work_in[0]  = phys_handle;                  /* Handle-Nr.       */
  280.         for (i = 1; i < 10; work_in[i++] = 1);      /* alles Standard   */
  281.         work_in[10] = 2;                            /* RC-Koordinaten   */
  282.         v_opnvwk( work_in, &vdi_handle, work_out ); /* Bildschirm öffnen*/
  283.  
  284.         /* Kenngrö₧en des Desktops abfragen */
  285.  
  286.         w_pixel  = work_out[3];             /* Pixelbreite /-höhe       */
  287.         h_pixel  = work_out[4];             /*   in 1/1000 mm           */
  288.         color_max = work_out[13];           /* gleichz.darstellb.Farb.  */
  289.         color_palette = work_out[39];       /* verfügbare Farben        */
  290.         w_screen = work_out[0] + 1;         /* Bildschirmbreite /-höhe  */
  291.         h_screen = work_out[1] + 1;         /*       in Pixeln          */
  292.         vq_chcells(vdi_handle, &h_text, &w_text); /* in Stand.zeichen   */
  293.  
  294.  
  295.  
  296.         /* Maus abschalten (hier kein Maus-bedienbares Programm)    */
  297.  
  298.         graf_mouse(M_OFF, NULL);
  299.  
  300.         return(WAHR);
  301.  
  302.     } else
  303.         return(FALSCH);
  304. }
  305.  
  306.  
  307. /*------------------------------------------------------------------*/
  308.  
  309.  
  310. /**
  311.  ** close_vwork: Schaltet die Maus wieder an,
  312.  **              schlie₧t die Workstation
  313.  **              und die Applikation
  314.  **/
  315.  
  316. void close_vwork(void)
  317. {
  318.    graf_mouse(M_ON, NULL);
  319.  
  320.    v_clsvwk(vdi_handle);
  321.  
  322.    appl_exit();
  323. }
  324.  
  325.  
  326. /*------------------------------------------------------------------*/
  327.  
  328. /**
  329.  ** lese_pixel:  Liest ein einzelnes Pixel aus der Bitmap
  330.  **
  331.  **/
  332. int  lese_pixel(PicBuf *picbuf)
  333. {
  334.  
  335.     static int py_alt = -1; /* Vergleich, ob noch aktuelle Zeile    */
  336.     static RowBuf *zeile;   /* Pointer auf Zeile in Bitmap          */
  337.  
  338.     /* int  byte_pos;            Welches Byte (nicht Bit !) ?           */
  339.     /* int byte_inhalt;         Inhalt des Bytes in der Zeile       */
  340.     /* int bit_pos;             Lage des ges. Bits (Pixels) im Byte */
  341.     /* int bit_inhalt;           Bit (Pixel) gesetzt ?              */
  342.  
  343.     py = dy - dy_min + oy;
  344.     px = dx - dx_min + ox;
  345.  
  346.     if (py != py_alt) {
  347.  
  348.         zeile = get_RowBuf(picbuf, picbuf->nr - (py + 1));
  349.  
  350.     } /* endif */
  351.  
  352.     /** Ursprüngliche Version ...
  353.      **  byte_pos = px >> 3;
  354.      **  byte_inhalt = (int) zeile->buf[byte_pos];
  355.      **
  356.      **  bit_pos = px % 8;
  357.      **  bit_inhalt = (byte_inhalt >> (7 - bit_pos)) & 1;
  358.      **
  359.      ** neue Version ...
  360.      **/
  361.     return((((int) zeile->buf[px >> 3]) >> (7 - (px % 8))) & 1);
  362.  
  363. }
  364.  
  365. /*------------------------------------------------------------------*/
  366.  
  367. /**
  368.  ** zeichne_pixelreihe:  Gibt eine Pixelreihe auf dem Schirm aus
  369.  **
  370.  **/
  371. void zeichne_pixelreihe (void)
  372. {
  373.  
  374.     register int in_Arbeit = 0; /* Gerade Linienstück in Arbeit?*/
  375.     register int start;         /* Beginn ...                   */
  376.     register int stop;          /* ... Ende eines Linienstücks  */
  377.     register int pos = 0;       /* Position 0 ... n             */
  378.     register int n = rx_max - rx_min;
  379.  
  380.     while (pos <= n) {
  381.  
  382.         if (rx_reihe[pos] != 0) {
  383.  
  384.             /* Pixel gesetzt */
  385.             if (in_Arbeit == 0) {
  386.  
  387.                 start = pos;
  388.                 in_Arbeit = 1;
  389.  
  390.             } /* endif */
  391.  
  392.             stop = pos;
  393.  
  394.         } else {
  395.  
  396.             /* Pixel nicht gesetzt */
  397.             if (in_Arbeit == 1) {
  398.  
  399.                 /* Linie ausgeben */
  400.                 pxyarray[0] = dx_min / rx_factor + start;   /* x1 */
  401.                 pxyarray[1] = ry;                           /* y1 */
  402.                 pxyarray[2] = dx_min / rx_factor + stop;    /* x2 */
  403.                 pxyarray[3] = ry;                           /* y2 */
  404.                 v_pline(vdi_handle, 2, pxyarray);
  405.  
  406.                 in_Arbeit = 0;
  407.  
  408.             } /* endif */
  409.  
  410.         } /* endif */
  411.  
  412.         if (pos == n) {
  413.  
  414.             if (in_Arbeit == 1) {
  415.  
  416.                 /* Linie ausgeben */
  417.                 pxyarray[0] = dx_min / rx_factor + start;   /* x1 */
  418.                 pxyarray[1] = ry;                           /* y1 */
  419.                 pxyarray[2] = dx_min / rx_factor + stop;    /* x2 */
  420.                 pxyarray[3] = ry;                           /* y2 */
  421.                 v_pline(vdi_handle, 2, pxyarray);
  422.  
  423.             } /* endif */
  424.  
  425.         } /* endif */
  426.  
  427.         pos += 1;
  428.  
  429.     } /* endwhile */
  430.  
  431. }
  432.  
  433.  
  434. /*------------------------------------------------------------------*/
  435.  
  436. /**
  437.  ** zeichne: Steuert das eigentliche Darstellen der Graphik
  438.  **
  439.  **/
  440.  
  441. void    zeichne (PicBuf *picbuf)
  442. {
  443.  
  444.     register int i;     /* Zähler für kleine Hilfsschleifen     */
  445.     register int rx_n;  /* Zähler zum "Sammeln" von Pixeln      */
  446.     register int ry_n;  /* Zähler zum "Sammeln" von Pixelreihen */
  447.     int pixel;          /* Einzelnes Pixel                      */
  448.  
  449.     CLS     /* Bildschirm löschen   */
  450.  
  451.     /* Ggf. graue / grüne Ränder am Bildschirmrand          */
  452.  
  453.     if (sx_max > px_max) {
  454.  
  455.         /* seitlichen Rand zeichnen */
  456.  
  457.         if (dx_min > 0) {
  458.  
  459.             /* linker Rand */
  460.             pxyarray[0] = 0;                            /* x1   */
  461.             pxyarray[1] = 0;                            /* y1   */
  462.             pxyarray[2] = (dx_min - 1) / rx_factor;     /* x2   */
  463.             pxyarray[3] = h_screen - 1;                 /* y2   */
  464.             v_bar(vdi_handle, pxyarray);
  465.  
  466.         } /* endif */
  467.  
  468.         if (dx_max < w_screen * rx_factor - 1) {
  469.  
  470.             /* rechter Rand */
  471.             pxyarray[0] = (dx_max + 1) / rx_factor;     /* x1   */
  472.             pxyarray[1] = 0;                            /* y1   */
  473.             pxyarray[2] = w_screen - 1;                 /* x2   */
  474.             pxyarray[3] = h_screen - 1;                 /* y2   */
  475.             v_bar(vdi_handle, pxyarray);
  476.  
  477.         } /* endif */
  478.  
  479.     } /* endif */
  480.  
  481.     if (sy_max > py_max) {
  482.  
  483.         /* Rand oben/unten zeichnen */
  484.  
  485.         if (dy_min > 0) {
  486.  
  487.             /* oberer Rand */
  488.             pxyarray[0] = 0;                            /* x1   */
  489.             pxyarray[1] = 0;                            /* y1   */
  490.             pxyarray[2] = w_screen - 1;                 /* x2   */
  491.             pxyarray[3] = (dy_min - 1) / ry_factor;     /* y2   */
  492.             v_bar(vdi_handle, pxyarray);
  493.  
  494.         } /* endif */
  495.  
  496.         if (dy_max < h_screen * ry_factor - 1) {
  497.  
  498.             /* unterer Rand */
  499.             pxyarray[0] = 0;                            /* x1   */
  500.             pxyarray[1] = (dy_max + 1) / ry_factor;     /* y1   */
  501.             pxyarray[2] = w_screen - 1;                 /* x2   */
  502.             pxyarray[3] = h_screen - 1;                 /* y2   */
  503.             v_bar(vdi_handle, pxyarray);
  504.  
  505.         } /* endif */
  506.  
  507.     } /* endif */
  508.  
  509.  
  510.     /* Steuerung der Pixeldarstellung               */
  511.  
  512.     dy = dy_min;
  513.     ry = ry_min;
  514.  
  515.     while (dy <= dy_max) {
  516.  
  517.         for (i = 0; i <= rx_max - rx_min; i++) {
  518.  
  519.             rx_reihe[i] = 0;
  520.  
  521.         } /* endfor */
  522.  
  523.         ry_n = 1;
  524.  
  525.         while (ry_n <= ry_factor && dy <= dy_max) {
  526.  
  527.             dx = dx_min;
  528.             rx = rx_min;
  529.  
  530.             while (dx <= dx_max) {
  531.  
  532.                 rx_n = 1;
  533.  
  534.                 while (rx_n <= rx_factor && dx <= dx_max) {
  535.  
  536.                     pixel = lese_pixel(picbuf);
  537.                     rx_reihe[rx - rx_min] = rx_reihe[rx - rx_min] | pixel;
  538.                     dx += 1;
  539.                     rx_n += 1;
  540.  
  541.                 } /* endwhile */
  542.  
  543.                 rx += 1;
  544.  
  545.             } /* endwhile */
  546.  
  547.                 ry_n += 1;
  548.                 dy += 1;
  549.  
  550.         } /* endwhile */
  551.  
  552.             zeichne_pixelreihe();
  553.             ry += 1;
  554.  
  555.     } /* endwhile */
  556.  
  557. }
  558.  
  559.  
  560. /*------------------------------------------------------------------*/
  561.  
  562. /**
  563.  ** hilfe:   Gibt Hilfstext aus
  564.  **
  565.  **/
  566.  
  567. void    hilfe (void)
  568. {
  569.  
  570.     static char *hilfe80 =
  571.  
  572.         "                            ATARI PREVIEWER  H I L F E\n"
  573.         "                            ==========================\n"
  574.         "\n"
  575.         "     <H>\n"
  576.         "oder <Help>         Diesen Hilfstext anzeigen lassen\n"
  577.         "oder <F1>\n"
  578.         "\n"
  579.         "     <I>            Information über wichtigste Kenngrö₧en des Bildschirms\n"
  580.         "                    anzeigen lassen\n"
  581.         "\n"
  582.         "     <Esc>          Previewer verlassen, Programm beenden\n"
  583.         "oder <Q>\n"
  584.         "\n"
  585.         "     <Pfeiltasten>  Verschieben des aktuellen Bildausschnittes in Richtung\n"
  586.         "                    des Pfeils (wenn möglich). Die Verschiebung kann durch\n"
  587.         "                    gleichzeitiges Drücken weiterer Tasten variiert\n"
  588.         "                    werden:\n"
  589.         "\n"
  590.         "                    <keine weitere Taste>   bildschirmweise verschieben\n"
  591.         "                    <Control>               jeweils 1/8 Bildschirmbreite\n"
  592.         "                    <Shift>                 pixelweise verschieben\n"
  593.         "\n"
  594.         "\n"
  595.         ">>> Zur Programmfortsetzung bitte Taste drücken <<<";
  596.  
  597.     static char *hilfe40 =
  598.  
  599.         "ATARI PREVIEWER  H I L F E\n"
  600.         "==========================\n"
  601.         "<H> oder <Help> oder <F1>\n"
  602.         "    Diesen Hilfstext anzeigen lassen\n"
  603.         "<I>\n"
  604.         "    Information über wichtigste Kenn-\n"
  605.         "    grö₧en des Bildschirms anzeigen\n"
  606.         "    lassen\n"
  607.         "<Esc> oder <Q>\n"
  608.         "    Previewer verlassen, Programm\n"
  609.         "    beenden\n"
  610.         "<Pfeiltasten>\n"
  611.         "    Verschieben des aktuellen Bildaus-\n"
  612.         "    schnittes in Richtung des Pfeils\n"
  613.         "    (wenn möglich). Die Verschiebung\n"
  614.         "    kann durch gleichzeitiges Drücken\n"
  615.         "    weiterer Tasten variiert werden:\n"
  616.         "    <keine weitere Taste>\n"
  617.         "        bildschirmweise verschieben\n"
  618.         "    <Control>\n"
  619.         "        jeweils 1/8 Bildschirmbreite\n"
  620.         "    <Shift>\n"
  621.         "        pixelweise verschieben\n"
  622.         "\n"
  623.         ">>> Bitte Taste drücken <<<";
  624.  
  625.  
  626.     CLS
  627.  
  628.     if (w_text < 80) {
  629.  
  630.         fprintf(stderr, "%s",hilfe40);
  631.  
  632.     } else {
  633.  
  634.         fprintf(stderr, "%s",hilfe80);
  635.  
  636.     } /* endif */
  637.  
  638. }
  639.  
  640. /*------------------------------------------------------------------*/
  641.  
  642. /**
  643.  ** info:    Gibt Information über alle wichtigen Kenngrö₧en der
  644.  **          aktuellen Bildschirmauflösung aus
  645.  **
  646.  **/
  647.  
  648. void    info  (void)
  649. {
  650.  
  651.     CLS                             /* Bildschirm löschen   */
  652.  
  653.     fprintf(stderr, "Bildschirmkenngrö₧en-Info\n");
  654.     fprintf(stderr, "=========================\n\n");
  655.  
  656.     fprintf(stderr, "Bildschirmbreite:  %4d\n",w_screen);
  657.     fprintf(stderr, "-höhe [Pixel]:     %4d\n",h_screen);
  658.     fprintf(stderr, "\n");
  659.     fprintf(stderr, "Pixelbreite [%cm]:  %4d\n",230,w_pixel);
  660.     fprintf(stderr, "Pixelhöhe   [%cm]:  %4d\n",230,h_pixel);
  661.     fprintf(stderr, " ( Verh.(x / y) %c %4d\n",247,rx_factor);
  662.     fprintf(stderr, "   Verh.(y / x) %c %4d )\n",247,ry_factor);
  663.     fprintf(stderr, "\n");
  664.     fprintf(stderr, "Buchstabenbreite:  %4d\n",gl_wchar);
  665.     fprintf(stderr, "- höhe [Pixel]:    %4d\n",gl_hchar);
  666.     fprintf(stderr, "\n");
  667.     fprintf(stderr, "\"Box\"breite:       %4d\n",gl_wbox);
  668.     fprintf(stderr, "\"Box\"höhe [Pixel]: %4d\n",gl_hbox);
  669.     fprintf(stderr, "\n");
  670.     fprintf(stderr, "Zeichen/Zeile:     %4d\n",w_text);
  671.     fprintf(stderr, "Zeilen/Bildschirm: %4d\n",h_text);
  672.     fprintf(stderr, "\n");
  673.     fprintf(stderr, "Farbenzahl:        %4d\n",color_max);
  674.     fprintf(stderr, "Farbennuancen:     %4d\n",color_palette);
  675.  
  676.     fprintf(stderr, "\n>>> Taste drücken <<<\n");
  677.  
  678. }
  679.  
  680. /*------------------------------------------------------------------*/
  681.  
  682. /**
  683.  ** preview: Koordiniert alle Aktivitäten wie Hilfstext anzeigen,
  684.  **          eigentlichen Preview durchführen, Tastendrücke aus-
  685.  **          werten usw.
  686.  **
  687.  **/
  688.  
  689. void preview(PicBuf *picbuf)
  690. {
  691.     long    scancode;   /* Scancode der gedrückten Taste    */
  692.     long    kbret  = 0; /* Stellung der Sondertasten        */
  693.     boolean newdraw;    /* Neues Zeichnen nötig?            */
  694.  
  695.     /* Ausgabe der Begrü₧ungsmeldung    */
  696.     fprintf(stderr, "\n\n");
  697.     fprintf(stderr, "ATARI-Preview\n");
  698.     fprintf(stderr, "=============\n");
  699.     fprintf(stderr, "\n");
  700.     fprintf(stderr, "Bitte Taste drücken:\n");
  701.     fprintf(stderr, "\n");
  702.     fprintf(stderr, "<H>, <F1> oder <Help> für Hilfstext\n");
  703.     fprintf(stderr, "<Q> oder <Esc>        für Abbruch\n");
  704.     fprintf(stderr, "<beliebige Taste>     für Preview\n");
  705.     fprintf(stderr, "\n");
  706.     fprintf(stderr, "Hinweis:\n");
  707.     fprintf(stderr, "Die Hilfe-Funktion ist auch während\n");
  708.     fprintf(stderr, "des Previews aktiv\n");
  709.  
  710.     scancode = (Bconin(CON) >> 16) & 255;   /* Tastendruck abwarten */
  711.                                             /* Scancode extrahieren */
  712.  
  713.     if (scancode != SC_Q && scancode != SC_ESC) {
  714.  
  715.         /* erstmalige Vorbesetzung der Variablen der    */
  716.         /* verschiedenen Pixelsysteme                   */
  717.  
  718.         rx_factor = (int)((float)w_pixel / (float)h_pixel + 0.5);
  719.         rx_factor = (rx_factor > 1) ? rx_factor : 1;
  720.         ry_factor = (int)((float)h_pixel / (float)w_pixel + 0.5);
  721.         ry_factor = (ry_factor > 1) ? ry_factor : 1;
  722.  
  723.         sx_min = 0;
  724.         sx_max = w_screen * rx_factor;
  725.         sy_min = 0;
  726.         sy_max = h_screen * ry_factor;
  727.  
  728.         px_min = 0;
  729.         px_max = picbuf->nc;
  730.         py_min = 0;
  731.         py_max = picbuf->nr;
  732.  
  733.         ox = 0;
  734.         oy = 0;
  735.  
  736.         if (sx_max > px_max) {
  737.             dx_min = (sx_max - px_max) / 2;
  738.             dx_max = sx_max - dx_min - 1 - ((sx_max - px_max) % 2);
  739.         } else {
  740.             dx_min = sx_min;
  741.             dx_max = sx_max - 1;
  742.         }
  743.         if (sy_max > py_max) {
  744.             dy_min = (sy_max - py_max) / 2;
  745.             dy_max = sy_max - dy_min - 1 - ((sy_max - py_max) % 2);
  746.         } else {
  747.             dy_min = sy_min;
  748.             dy_max = sy_max - 1;
  749.         }
  750.  
  751.         rx_min = dx_min / rx_factor;
  752.         rx_max = dx_max / rx_factor;
  753.         ry_min = dy_min / ry_factor;
  754.         ry_max = dy_max / ry_factor;
  755.  
  756.  
  757.         /* Graphikparameter zum Zeichnen vorbesetzen            */
  758.  
  759.         /* Clipping an Bildschirmgrenzen    */
  760.         pxyarray[0] = 0;            pxyarray[1] = 0;
  761.         pxyarray[2] = w_screen - 1; pxyarray[3] = h_screen - 1;
  762.         vs_clip(vdi_handle, 1, pxyarray);
  763.  
  764.         /* Stil für Flächen: grau (s/w) oder grün (Farbe)       */
  765.         vsf_perimeter(vdi_handle, 0);       /* kein Rahmen      */
  766.         if(color_max < 4) {
  767.             vsf_interior(vdi_handle, 2);    /* Füllstil: Muster */
  768.             vsf_style(vdi_handle, 4);       /* Muster: grau     */
  769.             vsf_color(vdi_handle, BLACK);   /* Füllfarbe        */
  770.         } else {
  771.             vsf_interior(vdi_handle, 1);    /* Füllstil: voll   */
  772.             vsf_color(vdi_handle, GREEN);   /* Füllfarbe        */
  773.         } /* endif */
  774.  
  775.         /* Stil für Linien festlegen */
  776.         vsl_type(vdi_handle, SOLID);        /* Linienstil           */
  777.         vsl_width(vdi_handle, 1);           /* L.breite (ungerade!) */
  778.         vsl_ends(vdi_handle,0,0);           /* Linienenden          */
  779.         vsl_color(vdi_handle, BLACK);       /* Linienfarbe          */
  780.  
  781.  
  782.         /* Schleifenvorbereitung: Vom Begrü₧ungstext aus        */
  783.         /* darf nur <H>, <Help> oder <F1> eine Bedeutung haben  */
  784.         if (scancode != SC_H  &&  scancode != SC_HELP &&
  785.             scancode != SC_F1)
  786.             scancode = 0;
  787.         /* es soll immer am Anfang einmal gezeichnet werden     */
  788.         newdraw = TRUE;
  789.  
  790.         /* Tastaturabfrage-Schleife, bis Ende gewünscht         */
  791.         while (scancode != SC_Q && scancode != SC_ESC) {
  792.  
  793.             /* Hilfstext auf Wunsch ausgeben                    */
  794.  
  795.             if (scancode == SC_H  ||  scancode == SC_HELP ||
  796.                 scancode == SC_F1) {
  797.  
  798.                 hilfe();
  799.                 newdraw = TRUE;
  800.  
  801.             } else {
  802.  
  803.                 /* Graphik-Information auf Wunsch ausgeben          */
  804.  
  805.                 if (scancode == SC_I) {
  806.  
  807.                     info();
  808.                     newdraw = TRUE;
  809.  
  810.                 } else {
  811.  
  812.  
  813.  
  814.                     /* gemä₧ letztem Tastendruck - wenn sinnvoll -  */
  815.                     /* Bildausschnitt neu zeichnen                  */
  816.  
  817.                     /* Tastendruckauswertung    */
  818.                     if (scancode == SC_PF_OBN || scancode == SC_PF_UTN) {
  819.  
  820.                         if (sy_max < py_max) {
  821.  
  822.                             if (scancode == SC_PF_OBN) {
  823.  
  824.                                 if (oy > 0) {
  825.  
  826.                                     if ((kbret & KB_CONTROL) > 0) {
  827.  
  828.                                         oy -= sy_max / 8;
  829.  
  830.                                     } else {
  831.  
  832.                                         if (((kbret & KB_SHIFT_RTS) | (kbret & KB_SHIFT_LKS)) > 0) {
  833.  
  834.                                             oy -= 1;
  835.  
  836.                                         } else {
  837.  
  838.                                             oy -= sy_max;
  839.  
  840.                                         } /* endif */
  841.  
  842.                                     } /* endif */
  843.  
  844.                                     if (oy < 0) {
  845.  
  846.                                         oy = 0;
  847.  
  848.                                     } /* endif */
  849.  
  850.                                     newdraw = TRUE;
  851.  
  852.                                 } /* endif */
  853.  
  854.                             } else {
  855.  
  856.                                 if (oy < py_max - sy_max) {
  857.  
  858.                                     if ((kbret & KB_CONTROL) > 0) {
  859.  
  860.                                         oy += sy_max / 8;
  861.  
  862.                                     } else {
  863.  
  864.                                         if (((kbret & KB_SHIFT_RTS) | (kbret & KB_SHIFT_LKS)) > 0) {
  865.  
  866.                                             oy += 1;
  867.  
  868.                                         } else {
  869.  
  870.                                             oy += sy_max;
  871.  
  872.                                         } /* endif */
  873.  
  874.                                     } /* endif */
  875.  
  876.                                     if (oy > py_max - sy_max) {
  877.  
  878.                                         oy = py_max - sy_max;
  879.  
  880.                                     } /* endif */
  881.  
  882.                                     newdraw = TRUE;
  883.  
  884.                                 } /* endif */
  885.  
  886.                             } /* endif */
  887.  
  888.                         } /* endif */
  889.  
  890.                     } else {
  891.  
  892.                         if (scancode == SC_PF_RTS || scancode == SC_C_PF_RTS ||
  893.                             scancode == SC_PF_LKS || scancode == SC_C_PF_LKS) {
  894.  
  895.                             if (sx_max < px_max) {
  896.  
  897.                                 if (scancode == SC_PF_LKS || scancode == SC_C_PF_LKS) {
  898.  
  899.                                     if (ox > 0) {
  900.  
  901.                                         if (scancode == SC_C_PF_LKS) {
  902.  
  903.                                             ox -= sx_max / 8;
  904.  
  905.                                         } else {
  906.  
  907.                                             if (((kbret & KB_SHIFT_RTS) | (kbret & KB_SHIFT_LKS))> 0) {
  908.  
  909.                                                 ox -= 1;
  910.  
  911.                                             } else {
  912.  
  913.                                                 ox -= sx_max;
  914.  
  915.                                             } /* endif */
  916.  
  917.                                         } /* endif */
  918.  
  919.                                         if (ox < 0) {
  920.  
  921.                                             ox = 0;
  922.  
  923.                                         } /* endif */
  924.  
  925.                                         newdraw = TRUE;
  926.  
  927.                                     } /* endif */
  928.  
  929.                                 } else {
  930.  
  931.                                     if (ox < px_max - sx_max) {
  932.  
  933.                                         if (scancode == SC_C_PF_RTS) {
  934.  
  935.                                             ox += sx_max / 8;
  936.  
  937.                                         } else {
  938.  
  939.                                             if (((kbret & KB_SHIFT_LKS) | (kbret & KB_SHIFT_RTS)) > 0) {
  940.  
  941.                                                 ox += 1;
  942.  
  943.                                             } else {
  944.  
  945.                                                 ox += sx_max;
  946.  
  947.                                             } /* endif */
  948.  
  949.                                         } /* endif */
  950.  
  951.                                         if (ox > px_max - sx_max) {
  952.  
  953.                                             ox = px_max - sx_max;
  954.  
  955.                                         } /* endif */
  956.  
  957.                                         newdraw = TRUE;
  958.  
  959.                                     } /* endif */
  960.  
  961.                                 } /* endif */
  962.  
  963.                             } /* endif */
  964.  
  965.                         } /* endif */
  966.  
  967.                     } /* endif */
  968.  
  969.                     if (newdraw == TRUE) {
  970.  
  971.                         zeichne(picbuf);
  972.                         newdraw = FALSE;
  973.  
  974.                     } /* endif */
  975.  
  976.                 } /* endif */
  977.  
  978.             } /* endif */
  979.  
  980.                 /* Tastendruck abwarten, Scancode extrahieren   */
  981.                 scancode = (Bconin(CON) >> 16) & 255;
  982.                 kbret    = Kbshift(-1); /* Sondertasten abfr.   */
  983.  
  984.         } /* endwhile */
  985.  
  986.  
  987.     } /* endif */
  988.  
  989. }
  990.  
  991. /*------------------------------------------------------------------*/
  992.  
  993.  
  994. /**
  995.  **  PicBuf_to_ATARI:    Hauptprogramm:
  996.  **                      - Initialisierung und Beenden des GEM
  997.  **                      - Aufruf der eigentlichen Preview-Funktionen
  998.  **/
  999.  
  1000. void    PicBuf_to_ATARI (PicBuf *picbuf, PAR *par)
  1001. {
  1002.     if (open_vwork() == TRUE) {
  1003.  
  1004.         Cursconf(0,1);          /* Cursor aus           */
  1005.         preview(picbuf);        /* Previewer aufrufen   */
  1006.         Cursconf(1,1);          /* Cursor ein           */
  1007.         close_vwork();
  1008.  
  1009.     } else {
  1010.  
  1011.         fprintf(stderr, "HP2xx - ATARI-Previewer\n");
  1012.         fprintf(stderr, "Fehler bei der GEM-Initialisierung!");
  1013.         exit(ERROR);
  1014.  
  1015.     }
  1016. }
  1017.  
  1018.  
  1019.